home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1998 / MacHack 1998.toast / The Hacks! / Talking KeyBoard / Source / AppleEvents / aeutils.c < prev    next >
Encoding:
Text File  |  1998-05-08  |  13.9 KB  |  495 lines  |  [TEXT/CWIE]
  1. // Program Author: Paul Baxter
  2. //    pbaxter@assistivetech.com
  3. //
  4. //
  5. // -----------------------------------------------------------------------
  6. //    Utility Routines for getting/Putting data from/to AEDesc's
  7. // -----------------------------------------------------------------------
  8.  
  9. #include "aeutils.h"
  10.  
  11.     
  12. // * ****************************************************************************** *
  13. // *    GetRawDataFromDescriptor
  14. // *                gets data in raw byte from Descriptor
  15. // * ****************************************************************************** *
  16. void GetRawDataFromDescriptor(const AEDesc *theDesc, Ptr destPtr, Size destMaxSize, Size *actSize)
  17. {
  18.     Size copySize;
  19.  
  20.     if (theDesc->dataHandle) {
  21.         HLock((Handle)theDesc->dataHandle);
  22.         *actSize = GetHandleSize((Handle)theDesc->dataHandle);
  23.         
  24.         copySize = LesserOf(*actSize, destMaxSize);
  25.         
  26.         BlockMove(*theDesc->dataHandle, destPtr, copySize);
  27.         
  28.         HUnlock((Handle)theDesc->dataHandle);
  29.     }
  30.     else
  31.         *actSize = 0;
  32. } /*GetRawDataFromDescriptor*/
  33.  
  34.  
  35. // * ****************************************************************************** *
  36. // *    PutBooleanToDescriptor
  37. // *                puts a Boolean into a Descriptor
  38. // * ****************************************************************************** *
  39. OSErr PutBooleanToDescriptor(AEDesc* aDesc, Boolean val)
  40. {
  41.     OSErr err;
  42.  
  43.     if (! aDesc)
  44.         return(errAETypeError);
  45.  
  46.     err = AECreateDesc(typeBoolean, (Ptr)&val, sizeof(val), aDesc);
  47.     return(err);
  48. }
  49.  
  50. // * ****************************************************************************** *
  51. // *    GetBooleanFromDescriptor
  52. // *                gets a Boolean from a Descriptor
  53. // * ****************************************************************************** *
  54. OSErr GetBooleanFromDescriptor(const AEDesc *sourceDesc, Boolean *result)
  55. {
  56.     OSErr  myErr;
  57.     OSErr  ignoreErr;
  58.     Size   boolSize;
  59.     AEDesc resultDesc;
  60.     
  61.     *result = false;
  62.     myErr = AECoerceDesc(sourceDesc,typeBoolean,&resultDesc);
  63.     
  64.     if (myErr==noErr) {
  65.             GetRawDataFromDescriptor(&resultDesc, (Ptr)result, sizeof(Boolean), &boolSize);
  66.             if (boolSize>sizeof(Boolean)) 
  67.                 myErr = errAECoercionFail;
  68.     }
  69.     
  70.     if (resultDesc.dataHandle) 
  71.         ignoreErr = AEDisposeDesc(&resultDesc);
  72.  
  73.     return(myErr);
  74. }
  75.  
  76. // * ****************************************************************************** *
  77. // *    PutIntegerToDescriptor
  78. // *                puts a short into a Descriptor
  79. // * ****************************************************************************** *
  80. OSErr PutIntegerToDescriptor(AEDesc* aDesc, short val)
  81. {
  82.     OSErr err;
  83.     
  84.     if (! aDesc)
  85.         return(errAETypeError);
  86.  
  87.     err = AECreateDesc(typeShortInteger, (Ptr)&val, sizeof(val), aDesc);
  88.     return(err);
  89. }
  90.  
  91. // * ****************************************************************************** *
  92. // *    GetIntegerFromDescriptor
  93. // *                gets a short from a Descriptor
  94. // * ****************************************************************************** *
  95. OSErr GetIntegerFromDescriptor(const AEDesc *sourceDesc, short *result)
  96. {
  97.     OSErr   myErr;
  98.     OSErr   ignoreErr;
  99.     Size    intSize;
  100.     AEDesc  resultDesc;
  101.     
  102.     *result = 0;
  103.     myErr  = AECoerceDesc(sourceDesc,typeShortInteger,&resultDesc);
  104.  
  105.     if (myErr==noErr) {
  106.         GetRawDataFromDescriptor(&resultDesc, (Ptr)result, 2, &intSize);
  107.         if (intSize>2) 
  108.             myErr = errAECoercionFail;
  109.     }
  110.  
  111.     if (resultDesc.dataHandle) 
  112.         ignoreErr = AEDisposeDesc(&resultDesc);
  113.         
  114.     return(myErr);
  115. }
  116.  
  117. // * ****************************************************************************** *
  118. // *    PutLongIntToDescriptor
  119. // *                puts a long into a Descriptor
  120. // * ****************************************************************************** *
  121. OSErr PutLongIntToDescriptor(AEDesc* aDesc, long val)
  122. {
  123.     OSErr        err;
  124.     
  125.     if (! aDesc)
  126.         return(errAETypeError);
  127.  
  128.     err = AECreateDesc(typeLongInteger, (Ptr)&val, sizeof(val), aDesc);
  129.     return(err);
  130. }
  131.  
  132. // * ****************************************************************************** *
  133. // *    GetLongIntFromDescriptor
  134. // *                gets a long from a Descriptor
  135. // * ****************************************************************************** *
  136. OSErr GetLongIntFromDescriptor(const AEDesc *sourceDesc, long *result)
  137. {
  138.     OSErr   myErr;
  139.     OSErr   ignoreErr;
  140.     Size    intSize;
  141.     AEDesc  resultDesc;
  142.         
  143.     *result = 0;
  144.     myErr = AECoerceDesc(sourceDesc,typeLongInteger,&resultDesc);
  145.     
  146.     if (myErr==noErr) 
  147.         {
  148.             GetRawDataFromDescriptor(&resultDesc, (Ptr)result, 4, &intSize);
  149.             if (intSize>4) 
  150.                 myErr = errAECoercionFail;
  151.         }
  152.     
  153.     if (resultDesc.dataHandle) 
  154.         ignoreErr = AEDisposeDesc(&resultDesc);
  155.         
  156.     return(myErr);
  157. } /*GetLongIntFromDescriptor*/
  158.  
  159.  
  160.  
  161. // * ****************************************************************************** *
  162. // *    PutHandleToDescriptor
  163. // *                puts handles data to a Descriptor for a named type
  164. // * ****************************************************************************** *
  165. OSErr PutHandleToDescriptor(AEDesc* aDesc, Handle thedata, long theType)
  166. {
  167.     OSErr    err;
  168.     char    state;
  169.  
  170.     if (! aDesc)
  171.         return(errAETypeError);
  172.  
  173.     state = HGetState(thedata);
  174.     HLock((Handle)thedata);
  175.     err = AECreateDesc(theType, (Ptr)*(thedata), GetHandleSize(thedata), aDesc);
  176.     HSetState(thedata, state);
  177.     return err;
  178. }
  179.  
  180. // * ****************************************************************************** *
  181. // *    GetHandleFromDescriptor
  182. // *                gets handles data from a Descriptor for a named type
  183. // * ****************************************************************************** *
  184. OSErr GetHandleFromDescriptor(const AEDesc* sourceDesc, Handle resultHandle, long theType)
  185. {
  186.     AEDesc  resultDesc;
  187.     OSErr   myErr;
  188.     OSErr   ignoreErr;
  189.     Size    resultsize, actSize;
  190.     char    state;
  191.  
  192.     myErr = AECoerceDesc(sourceDesc,theType,&resultDesc);
  193.  
  194.     if (myErr==noErr)  {
  195.         actSize = GetHandleSize((Handle)sourceDesc->dataHandle);
  196.         state = HGetState(resultHandle);
  197.         HUnlock(resultHandle);
  198.         SetHandleSize(resultHandle, actSize);
  199.         HLock(resultHandle);
  200.         GetRawDataFromDescriptor(&resultDesc, *resultHandle, actSize, &resultsize);
  201.         HSetState(resultHandle, state);
  202.         if (actSize!=resultsize) 
  203.             myErr = errAECoercionFail;
  204.     }
  205.  
  206.     if (resultDesc.dataHandle) 
  207.         ignoreErr = AEDisposeDesc(&resultDesc);
  208.  
  209.     return myErr;
  210. }
  211.  
  212. // * ****************************************************************************** *
  213. // *    PutRectToDescriptor
  214. // *                puts a Rectangle into a Descriptor
  215. // * ****************************************************************************** *
  216. OSErr PutRectToDescriptor(AEDesc* aDesc, Rect theRect)
  217. {
  218.     OSErr err;
  219.  
  220.     if (! aDesc)
  221.         return(errAETypeError);
  222.  
  223.     err = AECreateDesc(typeQDRectangle, (Ptr)&theRect, sizeof(theRect), aDesc);
  224.     return err;
  225. }
  226.  
  227. // * ****************************************************************************** *
  228. // *    GetRectFromDescriptor
  229. // *                gets a Rectangle from a Descriptor
  230. // * ****************************************************************************** *
  231. OSErr GetRectFromDescriptor(const AEDesc *sourceDesc, Rect *result)
  232. {
  233.     OSErr   myErr;
  234.     OSErr   ignoreErr;
  235.     Size    rectSize;
  236.     AEDesc  resultDesc;
  237.         
  238.     SetRect(result,0,0,0,0);
  239.     myErr = AECoerceDesc(sourceDesc,typeQDRectangle,&resultDesc);
  240.     
  241.     if (myErr==noErr)  {
  242.         GetRawDataFromDescriptor(&resultDesc, (Ptr)result, sizeof(Rect), &rectSize);
  243.         if (rectSize<sizeof(Rect)) 
  244.             myErr = errAECoercionFail;
  245.     }
  246.     
  247.     if (resultDesc.dataHandle) 
  248.         ignoreErr = AEDisposeDesc(&resultDesc);
  249.         
  250.     return(myErr);
  251. } /*GetRectFromDescriptor*/
  252.  
  253.  
  254. // * ****************************************************************************** *
  255. // *    PutPStringToDescriptor
  256. // *                puts a pascal string into a Descriptor
  257. // * ****************************************************************************** *
  258. OSErr PutPStringToDescriptor(AEDesc* aDesc, StringPtr pStr)
  259. {
  260.     OSErr        err;
  261.     
  262.     if (! aDesc || ! pStr)
  263.         return(errAETypeError);
  264.  
  265.     err = AECreateDesc(typeChar, (Ptr)&pStr[1], pStr[0], aDesc);
  266.         
  267.     return(err);
  268. }
  269.  
  270. // * ****************************************************************************** *
  271. // *    GetPStringFromDescriptor
  272. // *                gets a pascal string from a Descriptor
  273. // * ****************************************************************************** *
  274. OSErr GetPStringFromDescriptor(const AEDesc *aDesc, StringPtr resultStr)
  275. {
  276.     Size         stringSize;
  277.     AEDesc       resultDesc = {typeNull, NULL};
  278.     OSErr        err;
  279.     
  280.     err = AECoerceDesc(aDesc, typeChar, &resultDesc);
  281.     if (noErr != err) goto done;
  282.     
  283.     resultStr[0] = 0;
  284.     
  285.     GetRawDataFromDescriptor(&resultDesc, (Ptr)&resultStr[1], 255, &stringSize);
  286.     if (stringSize <= 255) 
  287.         resultStr[0] = stringSize;
  288.     else
  289.         err = errAECoercionFail;
  290.  
  291. done:        
  292.     if (resultDesc.dataHandle) 
  293.         AEDisposeDesc(&resultDesc);
  294.         
  295.     return(err);
  296. }
  297.  
  298. // * ****************************************************************************** *
  299. // *    PutPointToDescriptor
  300. // *                puts a Point into a Descriptor
  301. // * ****************************************************************************** *
  302. OSErr PutPointToDescriptor(AEDesc *aDesc, Point pt)
  303. {    
  304.     OSErr err;
  305.  
  306.     if (! aDesc)
  307.         return(errAETypeError);
  308.  
  309.     err= AECreateDesc(typeQDPoint, (Ptr)&pt, sizeof(pt), aDesc);
  310.     return err;
  311. }
  312.  
  313. // * ****************************************************************************** *
  314. // *    GetPointFromDescriptor
  315. // *                gets a Point from a Descriptor
  316. // * ****************************************************************************** *
  317. OSErr GetPointFromDescriptor(const AEDesc *sourceDesc, Point  *result)
  318. {
  319.     OSErr   myErr;
  320.     OSErr   ignoreErr;
  321.     Size    ptSize;
  322.     AEDesc  resultDesc;
  323.  
  324.     SetPt(result,0,0);
  325.  
  326.     myErr = AECoerceDesc(sourceDesc,typeQDPoint,&resultDesc);
  327.  
  328.     if (myErr==noErr)  {
  329.         GetRawDataFromDescriptor(&resultDesc, (Ptr)result, sizeof(Point),  &ptSize);
  330.                                                          
  331.         if (ptSize<sizeof(Point)) 
  332.             myErr = errAECoercionFail;                
  333.     }
  334.  
  335.     if (resultDesc.dataHandle) 
  336.         ignoreErr = AEDisposeDesc(&resultDesc);
  337.     
  338. return(myErr);
  339. } /*GetPointFromDescriptor*/
  340.  
  341.  
  342. // * ****************************************************************************** *
  343. // *    PutEnumeratedToDescriptor
  344. // *                puts an enum (unsigned long) into a Descriptor
  345. // * ****************************************************************************** *
  346. OSErr PutEnumeratedToDescriptor(AEDesc* aDesc, unsigned long enumval)
  347. {
  348.     OSErr        err;
  349.     
  350.     if (! aDesc)
  351.         return(errAETypeError);
  352.  
  353.     err = AECreateDesc(typeEnumerated, (Ptr)&enumval, sizeof(enumval), aDesc);
  354.  
  355.     return(err);
  356. }
  357.  
  358. // * ****************************************************************************** *
  359. // *    GetEnumeratedFromDescriptor
  360. // *                gets an enum from a Descriptor
  361. // * ****************************************************************************** *
  362. OSErr GetEnumeratedFromDescriptor(const AEDesc *sourceDesc, DescType  *result)
  363. {
  364.     OSErr   myErr;
  365.     OSErr   ignoreErr;
  366.     Size    enumSize;
  367.     AEDesc  resultDesc;
  368.  
  369.     *result = typeNull;
  370.     myErr = AECoerceDesc(sourceDesc,typeEnumerated,&resultDesc);
  371.  
  372.     if (myErr==noErr) {
  373.         GetRawDataFromDescriptor(&resultDesc, (Ptr)result, sizeof(DescType), &enumSize);
  374.     
  375.         if (enumSize<sizeof(DescType))
  376.             myErr = errAECoercionFail;
  377.     }
  378.     
  379.     if (resultDesc.dataHandle)
  380.         ignoreErr = AEDisposeDesc(&resultDesc);
  381.     
  382.     return(myErr);
  383. } // GetEnumeratedFromDescriptor
  384.  
  385.  
  386. // * ****************************************************************************** *
  387. // *    GotRequiredParams
  388. // *                Checks all parameters defined as 'required' have been read
  389. // * ****************************************************************************** *
  390. OSErr GotRequiredParams(const AppleEvent *theAppleEvent)
  391. {
  392.     DescType    returnedType;
  393.     Size        actualSize;
  394.     OSErr     err;
  395.     
  396.         // look for the keyMissedKeywordAttr, just to see if it's there
  397.     
  398.     err = AEGetAttributePtr(theAppleEvent, keyMissedKeywordAttr, typeWildCard,
  399.                                                 &returnedType, NULL, 0, &actualSize);
  400.     
  401.     switch (err) {
  402.         case errAEDescNotFound:        // attribute not there means we
  403.             err = noErr;            // got all required parameters.
  404.             break;
  405.             
  406.         case noErr:                    // attribute there means missed
  407.             err = errAEParamMissed;    // at least one parameter.
  408.             break;
  409.             
  410.         // default:        pass on unexpected error in looking for the attribute
  411.     }
  412.     
  413.     return(err);
  414. } // GotReqiredParams
  415.  
  416.  
  417. // * ****************************************************************************** *
  418. // *    AddResultToReply
  419. // *            This routine takes a result descriptor, a reply descriptor and an error.
  420. // *            If there is a result to add to the reply it makes sure the reply isn't
  421. // *            NULL itself then adds the result to the reply depending on the error
  422. // *            and the type of result.
  423. // * ****************************************************************************** *
  424. OSErr AddResultToReply(AEDesc* result, AEDesc* reply, OSErr error)
  425. {
  426.     OSErr err;
  427.  
  428.         // Check that the reply is not NULL and there is a result to put in it  
  429.     if (typeNull == reply->descriptorType || typeNull == result->descriptorType)
  430.         return(error);
  431.     
  432.     if (noErr == error)
  433.         err = AEPutParamDesc(reply, keyDirectObject, result);
  434.     else {
  435.         switch (result->descriptorType) {
  436.             case typeInteger:
  437.                 err = AEPutParamDesc(reply, keyErrorNumber, result);
  438.                 break;
  439.                 
  440.             case typeChar:
  441.                 err = AEPutParamDesc(reply, keyErrorString, result);
  442.                 break;
  443.                 
  444.             default:
  445.                 err = errAETypeError;
  446.         }
  447.         
  448.         if (noErr == err)
  449.             err = error;        // Don't loose that error
  450.     }
  451.  
  452.     return(err);
  453. }
  454.  
  455. // * ****************************************************************************** *
  456. // *    MakeSelfAddress
  457. // *            Builds an AEAddressDesc for the current process.
  458. // * ****************************************************************************** *
  459. OSErr MakeSelfAddress(AEAddressDesc *selfAddress)
  460. {
  461.     ProcessSerialNumber procSerNum;
  462.     
  463.     procSerNum.highLongOfPSN = 0;
  464.     procSerNum.lowLongOfPSN  = kCurrentProcess;
  465.     
  466.     return(AECreateDesc(typeProcessSerialNumber, (Ptr)&procSerNum, sizeof(procSerNum), selfAddress));
  467. } // MakeSelfAddress
  468.  
  469.  
  470. // * ****************************************************************************** *
  471. // *    LesserOf
  472. // *            Returns the Lesser of two longints.
  473. // * ****************************************************************************** *
  474. pascal long LesserOf(long A, long B)
  475.  {
  476.    if (A<B)
  477.        return(A);
  478.      else
  479.        return(B);
  480.  }   /*LesserOf*/
  481.             
  482.  
  483. // * ****************************************************************************** *
  484. // *    GreaterOf
  485. // *            Returns the greater of two longints.
  486. // * ****************************************************************************** *
  487. pascal long GreaterOf(long A, long B)
  488.  {
  489.    if (A>B)
  490.        return(A);
  491.      else
  492.        return(B);
  493.  }  /*GreaterOf*/
  494.             
  495.